package y.q.h.util.apicontroller;

import lombok.Data;
import lombok.experimental.Accessors;

import java.io.Serializable;
import java.util.Optional;

/**
 * REST API 返回结果
 *
 * @author hubin
 * @since 2018-06-05
 */
// @Deprecated
@Data
@Accessors(chain = true)
public class R<T> implements Serializable {

    /**
     * serialVersionUID
     */
    //private static final long serialVersionUID = 1L;

    /**
     * 业务错误码
     */
    private long code;
    /**
     * 结果集
     */
    private T data;
    /**
     * 描述
     */
    private String msg;
    /**
     * 数据总条数
     */
    private Integer count;

    /**
     * 默认构造函数
     */
    public R() {
        // to do nothing
    }

    /**
     * 使用给定的错误码构造对象
     *
     * @param errorCode 错误码对象
     */
    public R(IErrorCode errorCode) {
        errorCode = Optional.ofNullable(errorCode).orElse(ApiErrorCode.FAILED);
        this.code = errorCode.getCode();
        this.msg = errorCode.getMsg();
    }

    /**
     * 使用自定义状态码、提示信息构造对象
     *
     * @param code 状态码
     * @param msg  提示信息
     */
    public R(long code, String msg) {
        this.code = code;
        this.msg = msg;
    }

    /**
     * 使用自定义状态码、提示信息和数据构造对象
     *
     * @param code 状态码
     * @param msg  提示信息
     * @param data 数据
     */
    public R(long code, String msg, T data) {
        this.code = code;
        this.msg = msg;
        this.data = data;
    }
    /**
     * 创建一个成功的返回结果，包含指定的数据
     *
     * @return 成功的返回结果对象
     */
    public static <T> R<T> success() {

        return restResult(null,  ApiErrorCode.SUCCESS);
    }

    /**
     * 创建一个成功的返回结果，包含指定的数据
     *
     * @param data 数据
     * @param <T>  泛型类型
     * @return 成功的返回结果对象
     */
    public static <T> R<T> success(T data) {
        ApiErrorCode aec = ApiErrorCode.SUCCESS;
        return restResult(data, aec);
    }
    /**
     * 创建一个成功的返回结果，包含指定的数据和信息
     *
     * @param data  数据
     * @param msg 信息
     * @param <T>   泛型类型
     * @return 成功的返回结果对象
     */
    public static <T> R<T> success(String msg,T data) {

        return restResult(data, ApiErrorCode.SUCCESS.getCode(), msg);
    }


    /**
     * 创建一个成功的返回结果，包含指定的数据和数据总条数
     *
     * @param data  数据
     * @param count 数据总条数
     * @param <T>   泛型类型
     * @return 成功的返回结果对象
     */
    public static <T> R<T> success(T data, Integer count) {
        ApiErrorCode aec = ApiErrorCode.SUCCESS;
        if (data instanceof Boolean && Boolean.FALSE.equals(data)) {
            aec = ApiErrorCode.FAILED;
        }
        return restResult(data, aec, count);
    }


    /**
     * 是否成功 - 成功调用success，失败调用failed
     *
     * @param isSuccess boolean
     * @return {@link R }<{@link T }>
     * @date: 2023/12/31
     * @author SongRenShuo
     */
    public static <T> R<T> isSuccess(Boolean isSuccess) {
        if (isSuccess) {
            return success(null);
        }
        return failed("操作失败");
    }


    /**
     * 创建一个失败的返回结果，包含指定的提示信息
     *
     * @param msg 提示信息
     * @param <T> 泛型类型
     * @return 失败的返回结果对象
     */
    public static <T> R<T> failed(String msg) {
        return restResult(null, ApiErrorCode.FAILED.getCode(), msg);
    }

    /**
     * 创建一个失败的返回结果，包含指定的提示信息
     *
     * @param msg 提示信息
     * @param <T> 泛型类型
     * @return 失败的返回结果对象
     */
    public static <T> R<T> failed(String msg,T data) {
        return restResult(data, ApiErrorCode.FAILED.getCode(), msg);
    }

    /**
     * 创建一个失败的返回结果，使用给定的错误码对象
     *
     * @param errorCode 错误码对象
     * @param <T>       泛型类型
     * @return 失败的返回结果对象
     */
    public static <T> R<T> failed(IErrorCode errorCode) {
        return restResult(null, errorCode);
    }

    /**
     * 根据给定的错误码对象和数据创建返回结果对象
     *
     * @param data      数据
     * @param errorCode 错误码对象
     * @param <T>       泛型类型
     * @return 返回结果对象
     */
    public static <T> R<T> restResult(T data, IErrorCode errorCode) {
        return restResult(data, errorCode.getCode(), errorCode.getMsg());
    }

    /**
     * 根据给定的错误码对象、数据和数据总条数创建返回结果对象
     *
     * @param data      数据
     * @param errorCode 错误码对象
     * @param count     数据总条数
     * @param <T>       泛型类型
     * @return 返回结果对象
     */
    public static <T> R<T> restResult(T data, IErrorCode errorCode, Integer count) {
        return restResult(data, errorCode.getCode(), errorCode.getMsg(), count);
    }

    /**
     * 根据给定的状态码、提示信息和数据创建返回结果对象
     *
     * @param data 数据
     * @param code 状态码
     * @param msg  提示信息
     * @param <T>  泛型类型
     * @return 返回结果对象
     */
    private static <T> R<T> restResult(T data, long code, String msg) {
        R<T> apiResult = new R<>();
        apiResult.setCode(code);
        apiResult.setData(data);
        apiResult.setMsg(msg);
        return apiResult;
    }

    /**
     * 根据给定的状态码、提示信息、数据和数据总条数创建返回结果对象
     *
     * @param data  数据
     * @param code  状态码
     * @param msg   提示信息
     * @param count 数据总条数
     * @param <T>   泛型类型
     * @return 返回结果对象
     */
    private static <T> R<T> restResult(T data, long code, String msg, Integer count) {
        R<T> apiResult = new R<>();
        apiResult.setCode(code);
        apiResult.setData(data);
        apiResult.setMsg(msg);
        apiResult.setCount(count);
        return apiResult;
    }

    /**
     * 判断返回结果是否为成功状态
     *
     * @return 如果状态码为成功，则返回true，否则返回false
     */
    public boolean isCode() {
        return ApiErrorCode.SUCCESS.getCode() == code;
    }

}
